/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package framework.config;

import java.awt.Dimension;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.swing.ImageIcon;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

/**
 *
 * @author du
 */
public class Utilities
{
    /**
     * handleException
     *
     * @param e Exception
     */
    public static void handleException( Exception e )
    {
        StringWriter buffer = new StringWriter();
        PrintWriter writer = new PrintWriter( buffer );
        e.printStackTrace( writer );
        e.printStackTrace();

        JTextArea tArea = new JTextArea( "Um erro aconteceu ao tentar executar essa operação:\n\n" + buffer.toString() );
        tArea.setEditable( false );

        tArea.setPreferredSize( new Dimension( 500, 100 ) );

        JOptionPane.showMessageDialog( null, new JScrollPane( tArea ),
                "Erro!", JOptionPane.ERROR_MESSAGE );

        FileManager.getInstance().writeErrorLine( "\n[ " + getCurrentTime() + " ]\n" + buffer.toString() );
    }

    /**
     * getCurrentTime
     *
     * @return String
     */
    public static String getCurrentTime()
    {
        Date curTime = new Date( System.currentTimeMillis() );
        SimpleDateFormat sf = new SimpleDateFormat( "yyyy-MM-dd kk:mm" );

        return sf.format( curTime );
    }

    /**
     * getImage
     *
     * @param URL String
     * @return ImageIcon
     */
    public static ImageIcon getImage( String URL )
    {
        return new ImageIcon( Class.class.getResource( "/res/imagens/" + URL ) );
    }

    /**
     * getImage
     *
     * @param URL String
     * @return ImageIcon
     */
    public static InputStream getRelatorio( String relatorio )
    {
        return Class.class.getResourceAsStream( "/res/relatorios/" + relatorio );
    }
    
    /**
     * 
     * @param str_cnpj
     * @return 
     */
    public static boolean validaCnpj( String str_cnpj ) 
    {  
        if ( !str_cnpj.substring( 0, 1 ).equals( "" ) )
        {
            try
            {
                str_cnpj = str_cnpj.replace( '.', ' ' );
                str_cnpj = str_cnpj.replace( '/', ' ' );
                str_cnpj = str_cnpj.replace( '-', ' ' );
                str_cnpj = str_cnpj.replaceAll( " ", "" );
                int soma = 0, aux, dig;
                String cnpj_calc = str_cnpj.substring( 0, 12 );

                if ( str_cnpj.length() != 14 )
                {
                    return false;
                }
                char[] chr_cnpj = str_cnpj.toCharArray();
                /* Primeira parte */
                for ( int i = 0; i < 4; i++ )
                {
                    if ( chr_cnpj[i] - 48 >= 0 && chr_cnpj[i] - 48 <= 9 )
                    {
                        soma += ( chr_cnpj[i] - 48 ) * ( 6 - ( i + 1 ) );
                    }
                }
                for ( int i = 0; i < 8; i++ )
                {
                    if ( chr_cnpj[i + 4] - 48 >= 0 && chr_cnpj[i + 4] - 48 <= 9 )
                    {
                        soma += ( chr_cnpj[i + 4] - 48 ) * ( 10 - ( i + 1 ) );
                    }
                }
                dig = 11 - ( soma % 11 );
                cnpj_calc += ( dig == 10 || dig == 11 )
                        ? "0" : Integer.toString( dig );
                /* Segunda parte */
                soma = 0;
                for ( int i = 0; i < 5; i++ )
                {
                    if ( chr_cnpj[i] - 48 >= 0 && chr_cnpj[i] - 48 <= 9 )
                    {
                        soma += ( chr_cnpj[i] - 48 ) * ( 7 - ( i + 1 ) );
                    }
                }
                for ( int i = 0; i < 8; i++ )
                {
                    if ( chr_cnpj[i + 5] - 48 >= 0 && chr_cnpj[i + 5] - 48 <= 9 )
                    {
                        soma += ( chr_cnpj[i + 5] - 48 ) * ( 10 - ( i + 1 ) );
                    }
                }
                dig = 11 - ( soma % 11 );
                cnpj_calc += ( dig == 10 || dig == 11 )
                        ? "0" : Integer.toString( dig );
                return str_cnpj.equals( cnpj_calc );
            }
            catch ( Exception e )
            {
                System.err.println( "Erro !" + e );
                return false;
            }
        }
        else
        {
            return false;
        }
    }

    /**
     * 
     * @param strCpf
     * @return 
     */
    public static boolean validacpf( String strCpf )
    {
        if (strCpf.length() != 11) 
        {
            return false;
        }
        if ( !strCpf.substring( 0, 1 ).equals( "" ) )
        {
            try
            {
                boolean validado = true;
                int d1, d2;
                int digito1, digito2, resto;
                int digitoCPF;
                String nDigResult;
                strCpf = strCpf.replace( '.', ' ' );
                strCpf = strCpf.replace( '-', ' ' );
                strCpf = strCpf.replaceAll( " ", "" );
                d1 = d2 = 0;
                digito1 = digito2 = resto = 0;

                for ( int nCount = 1; nCount < strCpf.length() - 1; nCount++ )
                {
                    digitoCPF = Integer.valueOf( strCpf.substring( nCount - 1, nCount ) ).intValue();

                    //multiplique a ultima casa por 2 a seguinte por 3 a seguinte por 4 e assim por diante.  
                    d1 = d1 + ( 11 - nCount ) * digitoCPF;

                    //para o segundo digito repita o procedimento incluindo o primeiro digito calculado no passo anterior.  
                    d2 = d2 + ( 12 - nCount ) * digitoCPF;
                };

                //Primeiro resto da divisão por 11.  
                resto = ( d1 % 11 );

                //Se o resultado for 0 ou 1 o digito é 0 caso contrário o digito é 11 menos o resultado anterior.  
                if ( resto < 2 )
                {
                    digito1 = 0;
                }
                else
                {
                    digito1 = 11 - resto;
                }

                d2 += 2 * digito1;

                //Segundo resto da divisão por 11.  
                resto = ( d2 % 11 );

                //Se o resultado for 0 ou 1 o digito é 0 caso contrário o digito é 11 menos o resultado anterior.  
                if ( resto < 2 )
                {
                    digito2 = 0;
                }
                else
                {
                    digito2 = 11 - resto;
                }

                //Digito verificador do CPF que está sendo validado.  
                String nDigVerific = strCpf.substring( strCpf.length() - 2, strCpf.length() );

                //Concatenando o primeiro resto com o segundo.  
                nDigResult = String.valueOf( digito1 ) + String.valueOf( digito2 );

                //comparar o digito verificador do cpf com o primeiro resto + o segundo resto.  
                return nDigVerific.equals( nDigResult );
            }
            catch ( Exception e )
            {
                System.err.println( "Erro !" + e );
                return false;
            }
        }
        else
        {
            return false;
        }
    }
}
